ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളിൽ വിപ്ലവം: സോഴ്സ് ഫേസ് ഇമ്പോർട്ടിനെക്കുറിച്ചുള്ള ആഴത്തിലുള്ള പഠനം

ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റം നിരന്തരമായ പരിണാമത്തിലാണ്. ബ്രൗസറുകൾക്കായുള്ള ഒരു ലളിതമായ സ്ക്രിപ്റ്റിംഗ് ഭാഷ എന്ന നിലയിൽ നിന്ന്, സങ്കീർണ്ണമായ വെബ് ആപ്ലിക്കേഷനുകൾ മുതൽ സെർവർ-സൈഡ് ഇൻഫ്രാസ്ട്രക്ചർ വരെ എല്ലാത്തിനും ശക്തി പകരുന്ന ഒരു ആഗോള ശക്തിയായി അത് വളർന്നു. ഈ പരിണാമത്തിന്റെ ഒരു ആണിക്കല്ല് അതിന്റെ മൊഡ്യൂൾ സിസ്റ്റമായ ഇഎസ് മൊഡ്യൂൾസിന്റെ (ESM) നിലവാരപ്പെടുത്തലായിരുന്നു. എന്നിരുന്നാലും, ESM സാർവത്രിക നിലവാരമായി മാറിയപ്പോഴും, പുതിയ വെല്ലുവിളികൾ ഉയർന്നുവന്നിട്ടുണ്ട്, ഇത് സാധ്യമായതിന്റെ അതിരുകൾ ഭേദിക്കുന്നു. ഇത് TC39-ൽ നിന്നുള്ള ആവേശകരവും പരിവർത്തനാത്മകവുമായ ഒരു പുതിയ നിർദ്ദേശത്തിലേക്ക് നയിച്ചു: സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ്.

നിലവിൽ സ്റ്റാൻഡേർഡ് ട്രാക്കിലൂടെ മുന്നേറുന്ന ഈ നിർദ്ദേശം, ജാവാസ്ക്രിപ്റ്റിന് ഡിപൻഡൻസികൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നതിൽ ഒരു അടിസ്ഥാനപരമായ മാറ്റത്തെ പ്രതിനിധീകരിക്കുന്നു. ഇത് "ബിൽഡ് ടൈം" അല്ലെങ്കിൽ "സോഴ്സ് ഫേസ്" എന്ന ആശയം ഭാഷയിലേക്ക് നേരിട്ട് അവതരിപ്പിക്കുന്നു, കംപൈലേഷൻ സമയത്ത് മാത്രം പ്രവർത്തിക്കുന്ന മൊഡ്യൂളുകൾ ഇമ്പോർട്ട് ചെയ്യാൻ ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു, അത് അന്തിമ റൺടൈം കോഡിന്റെ ഭാഗമാകാതെ തന്നെ അതിനെ സ്വാധീനിക്കുന്നു. ഇത് നേറ്റീവ് മാക്രോകൾ, സീറോ-കോസ്റ്റ് ടൈപ്പ് അബ്സ്ട്രാക്ഷനുകൾ, കാര്യക്ഷമമായ ബിൽഡ്-ടൈം കോഡ് ജനറേഷൻ തുടങ്ങിയ ശക്തമായ ഫീച്ചറുകൾക്ക് വഴിയൊരുക്കുന്നു, എല്ലാം ഒരു സ്റ്റാൻഡേർഡ്, സുരക്ഷിത ചട്ടക്കൂടിനുള്ളിൽ.

ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്ക്, ജാവാസ്ക്രിപ്റ്റ് ടൂളിംഗ്, ഫ്രെയിംവർക്കുകൾ, ആപ്ലിക്കേഷൻ ആർക്കിടെക്ചർ എന്നിവയിലെ അടുത്ത നവീകരണ തരംഗത്തിനായി തയ്യാറെടുക്കുന്നതിന് ഈ നിർദ്ദേശം മനസ്സിലാക്കുന്നത് പ്രധാനമാണ്. ഈ സമഗ്രമായ ഗൈഡ് സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് എന്താണെന്നും, അവ പരിഹരിക്കുന്ന പ്രശ്നങ്ങളെക്കുറിച്ചും, അവയുടെ പ്രായോഗിക ഉപയോഗങ്ങളെക്കുറിച്ചും, ആഗോള ജാവാസ്ക്രിപ്റ്റ് കമ്മ്യൂണിറ്റിയിൽ അവ ചെലുത്താൻ പോകുന്ന ഗാഢമായ സ്വാധീനത്തെക്കുറിച്ചും പര്യവേക്ഷണം ചെയ്യും.

ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ സംക്ഷിപ്ത ചരിത്രം: ESM-ലേക്കുള്ള വഴി

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സിന്റെ പ്രാധാന്യം മനസ്സിലാക്കാൻ, നമ്മൾ ആദ്യം ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകളുടെ യാത്ര മനസ്സിലാക്കണം. അതിന്റെ ചരിത്രത്തിന്റെ ഭൂരിഭാഗവും, ജാവാസ്ക്രിപ്റ്റിന് ഒരു നേറ്റീവ് മൊഡ്യൂൾ സിസ്റ്റം ഇല്ലായിരുന്നു, ഇത് സർഗ്ഗാത്മകവും എന്നാൽ വിഘടിച്ചതുമായ പരിഹാരങ്ങളുടെ ഒരു കാലഘട്ടത്തിലേക്ക് നയിച്ചു.

ഗ്ലോബലുകളുടെയും IIFE-കളുടെയും കാലഘട്ടം

തുടക്കത്തിൽ, ഡെവലപ്പർമാർ ഒരു HTML ഫയലിൽ ഒന്നിലധികം <script> ടാഗുകൾ ലോഡ് ചെയ്തുകൊണ്ട് ഡിപൻഡൻസികൾ കൈകാര്യം ചെയ്തിരുന്നു. ഇത് ഗ്ലോബൽ നെയിംസ്പേസിനെ (ബ്രൗസറുകളിലെ window ഒബ്ജക്റ്റ്) മലിനമാക്കി, വേരിയബിൾ കൂട്ടിയിടികൾക്കും, പ്രവചനാതീതമായ ലോഡിംഗ് ഓർഡറുകൾക്കും, പരിപാലനത്തിലെ ഒരു പേടിസ്വപ്നത്തിനും കാരണമായി. ഇത് ലഘൂകരിക്കുന്നതിനുള്ള ഒരു സാധാരണ രീതിയായിരുന്നു ഇമ്മീഡിയറ്റ്ലി ഇൻവോക്ക്ഡ് ഫംഗ്ഷൻ എക്സ്പ്രഷൻ (IIFE), ഇത് ഒരു സ്ക്രിപ്റ്റിന്റെ വേരിയബിളുകൾക്ക് ഒരു സ്വകാര്യ സ്കോപ്പ് സൃഷ്ടിക്കുകയും അവ ഗ്ലോബൽ സ്കോപ്പിലേക്ക് ചോരുന്നത് തടയുകയും ചെയ്തു.

കമ്മ്യൂണിറ്റി നയിക്കുന്ന സ്റ്റാൻഡേർഡുകളുടെ ഉദയം

ആപ്ലിക്കേഷനുകൾ കൂടുതൽ സങ്കീർണ്ണമായതോടെ, കമ്മ്യൂണിറ്റി കൂടുതൽ ശക്തമായ പരിഹാരങ്ങൾ വികസിപ്പിച്ചു:

• കോമൺജെഎസ് (CJS): Node.js-ലൂടെ പ്രചാരം നേടിയ CJS, ഒരു സിൻക്രണസ് require() ഫംഗ്ഷനും ഒരു exports ഒബ്ജക്റ്റും ഉപയോഗിക്കുന്നു. ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് മൊഡ്യൂളുകൾ വായിക്കുന്നത് വേഗതയേറിയതും ബ്ലോക്കിംഗ് പ്രവർത്തനവുമായ സെർവറിനായി ഇത് രൂപകൽപ്പന ചെയ്‌തതാണ്. അതിന്റെ സിൻക്രണസ് സ്വഭാവം ബ്രൗസറിന് അത്ര അനുയോജ്യമല്ലായിരുന്നു, അവിടെ നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ അസിൻക്രണസ് ആണ്.
• അസിൻക്രണസ് മൊഡ്യൂൾ ഡെഫനിഷൻ (AMD): ബ്രൗസറിനായി രൂപകൽപ്പന ചെയ്ത AMD (അതിന്റെ ഏറ്റവും പ്രചാരമുള്ള നടപ്പാക്കലായ RequireJS), മൊഡ്യൂളുകൾ അസിൻക്രണസായി ലോഡ് ചെയ്തു. ഇതിന്റെ സിന്റാക്സ് കോമൺജെഎസിനേക്കാൾ വലുതായിരുന്നു, പക്ഷേ ക്ലയിന്റ്-സൈഡ് ആപ്ലിക്കേഷനുകളിലെ നെറ്റ്‌വർക്ക് ലേറ്റൻസി പ്രശ്നം പരിഹരിച്ചു.

സ്റ്റാൻഡേർഡൈസേഷൻ: ഇഎസ് മൊഡ്യൂളുകൾ (ESM)

ഒടുവിൽ, ECMAScript 2015 (ES6) ഒരു നേറ്റീവ്, സ്റ്റാൻഡേർഡ് മൊഡ്യൂൾ സിസ്റ്റം അവതരിപ്പിച്ചു: ഇഎസ് മൊഡ്യൂളുകൾ. ESM, സ്റ്റാറ്റിക്കായി വിശകലനം ചെയ്യാൻ കഴിയുന്ന വൃത്തിയുള്ളതും ഡിക്ലറേറ്റീവുമായ സിന്റാക്സ് (import, export) ഉപയോഗിച്ച് രണ്ട് ലോകങ്ങളിലെയും മികച്ചത് ഒരുമിപ്പിച്ചു. ഈ സ്റ്റാറ്റിക് സ്വഭാവം, കോഡ് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് തന്നെ ട്രീ-ഷേക്കിംഗ് (ഉപയോഗിക്കാത്ത കോഡ് നീക്കം ചെയ്യൽ) പോലുള്ള ഒപ്റ്റിമൈസേഷനുകൾ നടത്താൻ ബണ്ട്ലറുകൾ പോലുള്ള ടൂളുകളെ അനുവദിക്കുന്നു. ESM അസിൻക്രണസ് ആയി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു, ഇപ്പോൾ ബ്രൗസറുകളിലും Node.js-ലും സാർവത്രിക നിലവാരമാണ്, ഇത് വിഘടിച്ച ഇക്കോസിസ്റ്റത്തെ ഏകീകരിക്കുന്നു.

ആധുനിക ഇഎസ് മൊഡ്യൂളുകളുടെ മറഞ്ഞിരിക്കുന്ന പരിമിതികൾ

ESM ഒരു വലിയ വിജയമാണ്, പക്ഷേ അതിന്റെ രൂപകൽപ്പന റൺടൈം സ്വഭാവത്തിൽ മാത്രമായി കേന്ദ്രീകരിച്ചിരിക്കുന്നു. ഒരു import സ്റ്റേറ്റ്മെന്റ്, ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുമ്പോൾ ലഭ്യമാക്കുകയും പാഴ്സ് ചെയ്യുകയും എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യേണ്ട ഒരു ഡിപൻഡൻസിയെ സൂചിപ്പിക്കുന്നു. ഈ റൺടൈം-കേന്ദ്രീകൃത മാതൃക, ശക്തമാണെങ്കിലും, ഇക്കോസിസ്റ്റം ബാഹ്യവും നിലവാരമില്ലാത്തതുമായ ടൂളുകൾ ഉപയോഗിച്ച് പരിഹരിക്കുന്ന നിരവധി വെല്ലുവിളികൾ സൃഷ്ടിക്കുന്നു.

പ്രശ്നം 1: ബിൽഡ്-ടൈം ഡിപെൻഡൻസികളുടെ വ്യാപനം

ആധുനിക വെബ് ഡെവലപ്‌മെന്റ് ഒരു ബിൽഡ് സ്റ്റെപ്പിനെ വളരെയധികം ആശ്രയിച്ചിരിക്കുന്നു. നമ്മുടെ സോഴ്‌സ് കോഡിനെ പ്രൊഡക്ഷന് അനുയോജ്യമായ ഒപ്റ്റിമൈസ് ചെയ്ത ഫോർമാറ്റിലേക്ക് മാറ്റാൻ നമ്മൾ TypeScript, Babel, Vite, Webpack, PostCSS തുടങ്ങിയ ടൂളുകൾ ഉപയോഗിക്കുന്നു. ഈ പ്രക്രിയയിൽ റൺടൈമിൽ ആവശ്യമില്ലാത്തതും ബിൽഡ് സമയത്ത് മാത്രം ആവശ്യമുള്ളതുമായ നിരവധി ഡിപൻഡൻസികൾ ഉൾപ്പെടുന്നു.

ടൈപ്പ്സ്ക്രിപ്റ്റ് പരിഗണിക്കുക. നിങ്ങൾ import { type User } from './types' എന്ന് എഴുതുമ്പോൾ, റൺടൈമിൽ തത്തുല്യമില്ലാത്ത ഒരു എന്റിറ്റി നിങ്ങൾ ഇമ്പോർട്ട് ചെയ്യുകയാണ്. ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ ഈ ഇമ്പോർട്ടും ടൈപ്പ് വിവരങ്ങളും കംപൈലേഷൻ സമയത്ത് മായ്ച്ചുകളയും. എന്നിരുന്നാലും, ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂൾ സിസ്റ്റത്തിന്റെ കാഴ്ചപ്പാടിൽ, ഇത് മറ്റൊരു ഇമ്പോർട്ട് മാത്രമാണ്. ബണ്ട്ലറുകൾക്കും എഞ്ചിനുകൾക്കും ഈ "ടൈപ്പ്-ഒൺലി" ഇമ്പോർട്ടുകൾ കൈകാര്യം ചെയ്യാനും ഒഴിവാക്കാനും പ്രത്യേക ലോജിക് ഉണ്ടായിരിക്കണം, ഇത് ജാവാസ്ക്രിപ്റ്റ് ഭാഷാ സ്പെസിഫിക്കേഷന് പുറത്തുള്ള ഒരു പരിഹാരമാണ്.

പ്രശ്നം 2: സീറോ-കോസ്റ്റ് അബ്സ്ട്രാക്ഷനുകൾക്കായുള്ള അന്വേഷണം

ഒരു സീറോ-കോസ്റ്റ് അബ്സ്ട്രാക്ഷൻ എന്നത് ഡെവലപ്മെൻ്റ് സമയത്ത് ഉയർന്ന തലത്തിലുള്ള സൗകര്യം നൽകുന്നതും എന്നാൽ റൺടൈം ഓവർഹെഡ് ഇല്ലാതെ വളരെ കാര്യക്ഷമമായ കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നതുമായ ഒരു ഫീച്ചറാണ്. ഒരു മികച്ച ഉദാഹരണമാണ് ഒരു വാലിഡേഷൻ ലൈബ്രറി. നിങ്ങൾ ഇങ്ങനെ എഴുതിയേക്കാം:

validate(userSchema, userData);

റൺടൈമിൽ, ഇതിൽ ഒരു ഫംഗ്ഷൻ കോളും വാലിഡേഷൻ ലോജിക്കിന്റെ നിർവ്വഹണവും ഉൾപ്പെടുന്നു. ഭാഷയ്ക്ക്, ബിൽഡ് സമയത്ത്, സ്കീമ വിശകലനം ചെയ്യാനും വളരെ നിർദ്ദിഷ്ടവും ഇൻലൈൻ ചെയ്തതുമായ വാലിഡേഷൻ കോഡ് ജനറേറ്റ് ചെയ്യാനും, പൊതുവായ `validate` ഫംഗ്ഷൻ കോളും `userSchema` ഒബ്ജക്റ്റും അന്തിമ ബണ്ടിലിൽ നിന്ന് നീക്കം ചെയ്യാനും കഴിഞ്ഞാലോ? ഇത് നിലവിൽ ഒരു സ്റ്റാൻഡേർഡ് രീതിയിൽ ചെയ്യാൻ അസാധ്യമാണ്. മുഴുവൻ `validate` ഫംഗ്ഷനും `userSchema` ഒബ്ജക്റ്റും ക്ലയിന്റിലേക്ക് അയയ്ക്കണം, വാലിഡേഷൻ വ്യത്യസ്തമായി നടത്താനോ പ്രീ-കംപൈൽ ചെയ്യാനോ കഴിയുമായിരുന്നെങ്കിൽ പോലും.

പ്രശ്നം 3: സ്റ്റാൻഡേർഡ് മാക്രോകളുടെ അഭാവം

റസ്റ്റ്, ലിസ്പ്, സ്വിഫ്റ്റ് തുടങ്ങിയ ഭാഷകളിലെ ഒരു ശക്തമായ ഫീച്ചറാണ് മാക്രോകൾ. അവ അടിസ്ഥാനപരമായി കംപൈൽ സമയത്ത് കോഡ് എഴുതുന്ന കോഡുകളാണ്. ജാവാസ്ക്രിപ്റ്റിൽ, നമ്മൾ Babel പ്ലഗിനുകൾ അല്ലെങ്കിൽ SWC ട്രാൻസ്ഫോമുകൾ പോലുള്ള ടൂളുകൾ ഉപയോഗിച്ച് മാക്രോകളെ അനുകരിക്കുന്നു. ഇതിന്റെ ഏറ്റവും വ്യാപകമായ ഉദാഹരണമാണ് JSX:

const element = <h1>ഹലോ, വേൾഡ്</h1>;

ഇത് സാധുവായ ജാവാസ്ക്രിപ്റ്റ് അല്ല. ഒരു ബിൽഡ് ടൂൾ ഇതിനെ ഇങ്ങനെ മാറ്റുന്നു:

const element = React.createElement('h1', null, 'ഹലോ, വേൾഡ്');

ഈ പരിവർത്തനം ശക്തമാണ്, പക്ഷേ പൂർണ്ണമായും ബാഹ്യ ടൂളിംഗിനെ ആശ്രയിച്ചിരിക്കുന്നു. ഇത്തരത്തിലുള്ള സിന്റാക്സ് പരിവർത്തനം നടത്തുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കാൻ നേറ്റീവ് ആയ, ഭാഷയ്ക്കുള്ളിൽ ഒരു മാർഗവുമില്ല. ഈ നിലവാരമില്ലായ്മ സങ്കീർണ്ണവും പലപ്പോഴും ദുർബലവുമായ ഒരു ടൂളിംഗ് ശൃംഖലയിലേക്ക് നയിക്കുന്നു.

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് അവതരിപ്പിക്കുന്നു: ഒരു മാതൃകാപരമായ മാറ്റം

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് ഈ പരിമിതികൾക്കുള്ള നേരിട്ടുള്ള ഉത്തരമാണ്. ഈ നിർദ്ദേശം ഒരു പുതിയ ഇമ്പോർട്ട് ഡിക്ലറേഷൻ സിന്റാക്സ് അവതരിപ്പിക്കുന്നു, അത് ബിൽഡ്-ടൈം ഡിപൻഡൻസികളെ റൺടൈം ഡിപൻഡൻസികളിൽ നിന്ന് വ്യക്തമായി വേർതിരിക്കുന്നു.

പുതിയ സിന്റാക്സ് ലളിതവും അവബോധജന്യവുമാണ്: import source.

import { MyType } from './types.js'; // ഒരു സാധാരണ, റൺടൈം ഇമ്പോർട്ട്
import source { MyMacro } from './macros.js'; // ഒരു പുതിയ, സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്

അടിസ്ഥാന ആശയം: ഫേസ് വേർതിരിക്കൽ

കോഡ് മൂല്യനിർണ്ണയത്തിന്റെ രണ്ട് വ്യത്യസ്ത ഘട്ടങ്ങൾ ഔപചാരികമാക്കുക എന്നതാണ് പ്രധാന ആശയം:

1. സോഴ്സ് ഫേസ് (ബിൽഡ് ടൈം): ഈ ഘട്ടം ആദ്യം സംഭവിക്കുന്നു, ഇത് ഒരു ജാവാസ്ക്രിപ്റ്റ് "ഹോസ്റ്റ്" (ഒരു ബണ്ട്ലർ, Node.js അല്ലെങ്കിൽ Deno പോലുള്ള റൺടൈം, അല്ലെങ്കിൽ ഒരു ബ്രൗസറിന്റെ ഡെവലപ്‌മെന്റ്/ബിൽഡ് എൻവയോൺമെന്റ്) കൈകാര്യം ചെയ്യുന്നു. ഈ ഘട്ടത്തിൽ, ഹോസ്റ്റ് import source ഡിക്ലറേഷനുകൾക്കായി തിരയുന്നു. തുടർന്ന് അത് ഈ മൊഡ്യൂളുകളെ ഒരു പ്രത്യേക, ഒറ്റപ്പെട്ട പരിതസ്ഥിതിയിൽ ലോഡ് ചെയ്യുകയും എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. ഈ മൊഡ്യൂളുകൾക്ക് അവയെ ഇമ്പോർട്ട് ചെയ്യുന്ന മൊഡ്യൂളുകളുടെ സോഴ്സ് കോഡ് പരിശോധിക്കാനും പരിവർത്തനം ചെയ്യാനും കഴിയും.
2. റൺടൈം ഫേസ് (എക്സിക്യൂഷൻ ടൈം): ഇത് നമുക്കെല്ലാവർക്കും പരിചിതമായ ഘട്ടമാണ്. ജാവാസ്ക്രിപ്റ്റ് എഞ്ചിൻ അന്തിമവും, ഒരുപക്ഷേ പരിവർത്തനം ചെയ്യപ്പെട്ടതുമായ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. import source വഴി ഇമ്പോർട്ട് ചെയ്ത എല്ലാ മൊഡ്യൂളുകളും അവ ഉപയോഗിച്ച കോഡും പൂർണ്ണമായും അപ്രത്യക്ഷമാകുന്നു; അവ റൺടൈം മൊഡ്യൂൾ ഗ്രാഫിൽ ഒരു അടയാളവും അവശേഷിപ്പിക്കുന്നില്ല.

ഭാഷയുടെ സ്പെസിഫിക്കേഷനിലേക്ക് നേരിട്ട് നിർമ്മിച്ച ഒരു സ്റ്റാൻഡേർഡ്, സുരക്ഷിത, മൊഡ്യൂൾ-അവബോധമുള്ള പ്രീപ്രൊസസ്സറായി ഇതിനെ കരുതുക. ഇത് സി പ്രീപ്രൊസസ്സർ പോലുള്ള ടെക്സ്റ്റ് സബ്സ്റ്റിറ്റിയൂഷൻ മാത്രമല്ല; ഇത് ജാവാസ്ക്രിപ്റ്റിന്റെ ഘടനയുമായി, അതായത് അബ്സ്ട്രാക്റ്റ് സിന്റാക്സ് ട്രീകളുമായി (ASTs) പ്രവർത്തിക്കാൻ കഴിയുന്ന ആഴത്തിൽ സംയോജിപ്പിച്ച ഒരു സിസ്റ്റമാണ്.

പ്രധാന ഉപയോഗങ്ങളും പ്രായോഗിക ഉദാഹരണങ്ങളും

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സിന്റെ യഥാർത്ഥ ശക്തി, അവയ്ക്ക് മനോഹരമായി പരിഹരിക്കാൻ കഴിയുന്ന പ്രശ്നങ്ങൾ നോക്കുമ്പോൾ വ്യക്തമാകും. ഏറ്റവും സ്വാധീനം ചെലുത്തുന്ന ചില ഉപയോഗങ്ങൾ പര്യവേക്ഷണം ചെയ്യാം.

ഉപയോഗം 1: നേറ്റീവ്, സീറോ-കോസ്റ്റ് ടൈപ്പ് അനോട്ടേഷനുകൾ

ഈ നിർദ്ദേശത്തിന്റെ പ്രധാന പ്രേരകങ്ങളിലൊന്ന് TypeScript, Flow പോലുള്ള ടൈപ്പ് സിസ്റ്റങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റ് ഭാഷയ്ക്കുള്ളിൽ തന്നെ ഒരു നേറ്റീവ് ഇടം നൽകുക എന്നതാണ്. നിലവിൽ, `import type { ... }` ഒരു TypeScript-നിർദ്ദിഷ്ട ഫീച്ചറാണ്. സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് ഉപയോഗിച്ച്, ഇത് ഒരു സ്റ്റാൻഡേർഡ് ഭാഷാ നിർമ്മിതിയായി മാറുന്നു.

നിലവിൽ (ടൈപ്പ്സ്ക്രിപ്റ്റ്):

// types.ts
export interface User {
id: number;
name: string;
}

// app.ts
import type { User } from './types';
const user: User = { id: 1, name: 'Alice' };

ഭാവിയിൽ (സ്റ്റാൻഡേർഡ് ജാവാസ്ക്രിപ്റ്റ്):

// types.js
export interface User { /* ... */ } // ഒരു ടൈപ്പ് സിന്റാക്സ് നിർദ്ദേശവും അംഗീകരിക്കപ്പെട്ടുവെന്ന് കരുതുക

// app.js
import source { User } from './types.js';
const user: User = { id: 1, name: 'Alice' };

പ്രയോജനം: import source സ്റ്റേറ്റ്മെന്റ് ഏത് ജാവാസ്ക്രിപ്റ്റ് ടൂളിനോടോ എഞ്ചിനോടോ ./types.js ഒരു ബിൽഡ്-ടൈം-മാത്രം ഡിപൻഡൻസിയാണെന്ന് വ്യക്തമായി പറയുന്നു. റൺടൈം എഞ്ചിൻ ഒരിക്കലും അത് ലഭ്യമാക്കാനോ പാഴ്സ് ചെയ്യാനോ ശ്രമിക്കില്ല. ഇത് ടൈപ്പ് ഇറേസർ എന്ന ആശയത്തെ സ്റ്റാൻഡേർഡ് ആക്കുന്നു, ഇത് ഭാഷയുടെ ഔപചാരിക ഭാഗമാക്കുകയും ബണ്ട്ലറുകൾ, ലിന്ററുകൾ, മറ്റ് ടൂളുകൾ എന്നിവയുടെ ജോലി ലളിതമാക്കുകയും ചെയ്യുന്നു.

ഉപയോഗം 2: ശക്തവും വൃത്തിയുള്ളതുമായ മാക്രോകൾ

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സിന്റെ ഏറ്റവും പരിവർത്തനാത്മകമായ പ്രയോഗമാണ് മാക്രോകൾ. ജാവാസ്ക്രിപ്റ്റിന്റെ സിന്റാക്സ് വികസിപ്പിക്കാനും സുരക്ഷിതവും നിലവാരമുള്ളതുമായ രീതിയിൽ ശക്തമായ, ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷകൾ (DSLs) സൃഷ്ടിക്കാനും അവ ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു.

ബിൽഡ് സമയത്ത് ഫയലും ലൈൻ നമ്പറും സ്വയമേവ ഉൾപ്പെടുത്തുന്ന ഒരു ലളിതമായ ലോഗിംഗ് മാക്രോ സങ്കൽപ്പിക്കുക.

മാക്രോ നിർവ്വചനം:

// macros.js
export function log(macroContext) {
// 'macroContext' കോൾ സൈറ്റ് പരിശോധിക്കാൻ API-കൾ നൽകും
const callSite = macroContext.getCallSiteInfo(); // ഉദാഹരണത്തിന്, { file: 'app.js', line: 5 }
const messageArgument = macroContext.getArgument(0); // സന്ദേശത്തിനായുള്ള AST നേടുക // console.log കോളിനായി ഒരു പുതിയ AST നൽകുക
return `console.log("[${callSite.file}:${callSite.line}]", ${messageArgument})`;
}

മാക്രോ ഉപയോഗിക്കുമ്പോൾ:

// app.js
import source { log } from './macros.js'; const value = 42;
log(`The value is: ${value}`);

കംപൈൽ ചെയ്ത റൺടൈം കോഡ്:

// app.js (സോഴ്സ് ഫേസിന് ശേഷം)
const value = 42;
console.log("[app.js:5]", `The value is: ${value}`);

പ്രയോജനം: ബിൽഡ്-ടൈം വിവരങ്ങൾ നേരിട്ട് റൺടൈം കോഡിലേക്ക് ചേർക്കുന്ന കൂടുതൽ പ്രകടനാത്മകമായ ഒരു `log` ഫംഗ്ഷൻ നമ്മൾ സൃഷ്ടിച്ചു. റൺടൈമിൽ `log` ഫംഗ്ഷൻ കോൾ ഇല്ല, നേരിട്ടുള്ള `console.log` മാത്രം. ഇതൊരു യഥാർത്ഥ സീറോ-കോസ്റ്റ് അബ്സ്ട്രാക്ഷനാണ്. ഇതേ തത്വം JSX, സ്റ്റൈൽഡ്-കംപോണന്റ്സ്, ഇന്റർനാഷണലൈസേഷൻ (i18n) ലൈബ്രറികൾ, കൂടാതെ പലതും നടപ്പിലാക്കാൻ ഉപയോഗിക്കാം, എല്ലാം കസ്റ്റം Babel പ്ലഗിനുകൾ ഇല്ലാതെ.

ഉപയോഗം 3: സംയോജിത ബിൽഡ്-ടൈം കോഡ് ജനറേഷൻ

പല ആപ്ലിക്കേഷനുകളും മറ്റ് ഉറവിടങ്ങളിൽ നിന്ന് കോഡ് ജനറേറ്റ് ചെയ്യുന്നതിനെ ആശ്രയിക്കുന്നു, ഒരു GraphQL സ്കീമ, ഒരു പ്രോട്ടോക്കോൾ ബഫേഴ്സ് നിർവചനം, അല്ലെങ്കിൽ YAML അല്ലെങ്കിൽ JSON പോലുള്ള ഒരു ലളിതമായ ഡാറ്റാ ഫയൽ പോലെ.

നിങ്ങൾക്ക് ഒരു GraphQL സ്കീമ ഉണ്ടെന്നും അതിനായി ഒരു ഒപ്റ്റിമൈസ് ചെയ്ത ക്ലയിന്റ് ജനറേറ്റ് ചെയ്യണമെന്നും കരുതുക. ഇന്ന്, ഇതിന് ബാഹ്യ CLI ടൂളുകളും സങ്കീർണ്ണമായ ഒരു ബിൽഡ് സെറ്റപ്പും ആവശ്യമാണ്. സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് ഉപയോഗിച്ച്, ഇത് നിങ്ങളുടെ മൊഡ്യൂൾ ഗ്രാഫിന്റെ ഒരു സംയോജിത ഭാഗമായി മാറും.

ജനറേറ്റർ മൊഡ്യൂൾ:

// graphql-codegen.js
export function createClient(schemaText) {
// 1. schemaText പാഴ്സ് ചെയ്യുക
// 2. ടൈപ്പ് ചെയ്ത ക്ലയിന്റിനായി ജാവാസ്ക്രിപ്റ്റ് കോഡ് ജനറേറ്റ് ചെയ്യുക
// 3. ജനറേറ്റ് ചെയ്ത കോഡ് ഒരു സ്ട്രിംഗായി നൽകുക
const generatedCode = `
export const client = {
query: { /* ... ജനറേറ്റ് ചെയ്ത മെത്തേഡുകൾ ... */ }
};
`;
return generatedCode;
}

ജനറേറ്റർ ഉപയോഗിക്കുമ്പോൾ:

// app.js
// 1. ഇമ്പോർട്ട് അസേർഷനുകൾ ഉപയോഗിച്ച് സ്കീമ ടെക്സ്റ്റായി ഇമ്പോർട്ട് ചെയ്യുക (വേറിട്ട ഫീച്ചർ)
import schema from './api.graphql' with { type: 'text' }; // 2. സോഴ്സ് ഫേസ് ഇമ്പോർട്ട് ഉപയോഗിച്ച് കോഡ് ജനറേറ്റർ ഇമ്പോർട്ട് ചെയ്യുക
import source { createClient } from './graphql-codegen.js'; // 3. ബിൽഡ് സമയത്ത് ജനറേറ്റർ എക്സിക്യൂട്ട് ചെയ്യുകയും അതിന്റെ ഔട്ട്പുട്ട് ചേർക്കുകയും ചെയ്യുക
export const { client } = createClient(schema);

പ്രയോജനം: മുഴുവൻ പ്രക്രിയയും ഡിക്ലറേറ്റീവും സോഴ്സ് കോഡിന്റെ ഭാഗവുമാണ്. ബാഹ്യ കോഡ് ജനറേറ്റർ പ്രവർത്തിപ്പിക്കുന്നത് ഇനി ഒരു പ്രത്യേക, മാനുവൽ ഘട്ടമല്ല. `api.graphql` മാറുകയാണെങ്കിൽ, `app.js`-നായി സോഴ്സ് ഫേസ് വീണ്ടും പ്രവർത്തിപ്പിക്കണമെന്ന് ബിൽഡ് ടൂളിന് സ്വയമേവ അറിയാം. ഇത് ഡെവലപ്‌മെന്റ് വർക്ക്ഫ്ലോ ലളിതവും കൂടുതൽ കരുത്തുറ്റതും പിശകുകൾ കുറഞ്ഞതുമാക്കുന്നു.

അതെങ്ങനെ പ്രവർത്തിക്കുന്നു: ഹോസ്റ്റ്, സാൻഡ്ബോക്സ്, ഫേസുകൾ

ജാവാസ്ക്രിപ്റ്റ് എഞ്ചിൻ തന്നെ (Chrome-ലും Node.js-ലുമുള്ള V8 പോലെ) സോഴ്സ് ഫേസ് എക്സിക്യൂട്ട് ചെയ്യുന്നില്ലെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. ഉത്തരവാദിത്തം ഹോസ്റ്റ് എൻവയോൺമെന്റിനാണ്.

ഹോസ്റ്റിന്റെ പങ്ക്

ജാവാസ്ക്രിപ്റ്റ് കോഡ് കംപൈൽ ചെയ്യുകയോ പ്രവർത്തിപ്പിക്കുകയോ ചെയ്യുന്ന പ്രോഗ്രാമാണ് ഹോസ്റ്റ്. ഇത് ഇവയിലേതെങ്കിലും ആകാം:

• Vite, Webpack, അല്ലെങ്കിൽ Parcel പോലുള്ള ഒരു ബണ്ട്ലർ.
• Node.js അല്ലെങ്കിൽ Deno പോലുള്ള ഒരു റൺടൈം.
• ഒരു ബ്രൗസറിന് പോലും അതിന്റെ DevTools-ൽ അല്ലെങ്കിൽ ഒരു ഡെവലപ്‌മെന്റ് സെർവർ ബിൽഡ് പ്രോസസ്സിനിടെ എക്സിക്യൂട്ട് ചെയ്യുന്ന കോഡിനായി ഒരു ഹോസ്റ്റായി പ്രവർത്തിക്കാൻ കഴിയും.

ഹോസ്റ്റ് രണ്ട്-ഘട്ട പ്രക്രിയയെ ഏകോപിപ്പിക്കുന്നു:

1. അത് കോഡ് പാഴ്സ് ചെയ്യുകയും എല്ലാ import source ഡിക്ലറേഷനുകളും കണ്ടെത്തുകയും ചെയ്യുന്നു.
2. സോഴ്സ് ഫേസ് മൊഡ്യൂളുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനായി ഇത് ഒരു ഒറ്റപ്പെട്ട, സാൻഡ്ബോക്സ് ചെയ്ത എൻവയോൺമെന്റ് (പലപ്പോഴും "Realm" എന്ന് വിളിക്കുന്നു) സൃഷ്ടിക്കുന്നു.
3. ഈ സാൻഡ്ബോക്സിനുള്ളിൽ ഇമ്പോർട്ട് ചെയ്ത സോഴ്സ് മൊഡ്യൂളുകളിൽ നിന്നുള്ള കോഡ് അത് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഈ മൊഡ്യൂളുകൾക്ക് അവർ പരിവർത്തനം ചെയ്യുന്ന കോഡുമായി സംവദിക്കാൻ പ്രത്യേക API-കൾ (ഉദാഹരണത്തിന്, AST മാനിപ്പുലേഷൻ API-കൾ) നൽകുന്നു.
4. പരിവർത്തനങ്ങൾ പ്രയോഗിക്കപ്പെടുന്നു, അതിന്റെ ഫലമായി അന്തിമ റൺടൈം കോഡ് ലഭിക്കുന്നു.
5. ഈ അന്തിമ കോഡ് പിന്നീട് റൺടൈം ഘട്ടത്തിനായി സാധാരണ ജാവാസ്ക്രിപ്റ്റ് എഞ്ചിനിലേക്ക് കൈമാറുന്നു.

സുരക്ഷയും സാൻഡ്ബോക്സിംഗും നിർണ്ണായകമാണ്

ബിൽഡ് സമയത്ത് കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് സുരക്ഷാ അപകടസാധ്യതകൾക്ക് ഇടയാക്കും. ഒരു ക്ഷുദ്രകരമായ ബിൽഡ്-ടൈം സ്ക്രിപ്റ്റിന് ഡെവലപ്പറുടെ മെഷീനിലെ ഫയൽ സിസ്റ്റമോ നെറ്റ്‌വർക്കോ ആക്‌സസ് ചെയ്യാൻ ശ്രമിക്കാം. സോഴ്സ് ഫേസ് ഇമ്പോർട്ട് നിർദ്ദേശം സുരക്ഷയ്ക്ക് ശക്തമായ ഊന്നൽ നൽകുന്നു.

സോഴ്സ് ഫേസ് കോഡ് വളരെ നിയന്ത്രിതമായ ഒരു സാൻഡ്ബോക്സിലാണ് പ്രവർത്തിക്കുന്നത്. ഡിഫോൾട്ടായി, ഇതിന് ഇവയിലേക്ക് ആക്സസ് ഇല്ല:

• ലോക്കൽ ഫയൽ സിസ്റ്റം.
• നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ.
• window അല്ലെങ്കിൽ process പോലുള്ള റൺടൈം ഗ്ലോബലുകൾ.

ഫയൽ ആക്‌സസ് പോലുള്ള ഏതെങ്കിലും കഴിവുകൾ ഹോസ്റ്റ് എൻവയോൺമെന്റ് വ്യക്തമായി നൽകേണ്ടതുണ്ട്, ഇത് ബിൽഡ്-ടൈം സ്ക്രിപ്റ്റുകൾക്ക് എന്തുചെയ്യാൻ അനുവാദമുണ്ടെന്നതിൽ ഉപയോക്താവിന് പൂർണ്ണ നിയന്ത്രണം നൽകുന്നു. ഇത് പലപ്പോഴും സിസ്റ്റത്തിലേക്ക് പൂർണ്ണ ആക്‌സസ് ഉള്ള പ്ലഗിന്നുകളുടെയും സ്ക്രിപ്റ്റുകളുടെയും നിലവിലെ ഇക്കോസിസ്റ്റത്തേക്കാൾ വളരെ സുരക്ഷിതമാക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റത്തിലെ ആഗോള സ്വാധീനം

സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സിന്റെ ആമുഖം ആഗോള ജാവാസ്ക്രിപ്റ്റ് ഇക്കോസിസ്റ്റത്തിൽ ഉടനീളം അലയൊലികൾ സൃഷ്ടിക്കും, നമ്മൾ ടൂളുകളും ഫ്രെയിംവർക്കുകളും ആപ്ലിക്കേഷനുകളും നിർമ്മിക്കുന്ന രീതിയെ അടിസ്ഥാനപരമായി മാറ്റും.

ഫ്രെയിംവർക്ക്, ലൈബ്രറി രചയിതാക്കൾക്ക്

React, Svelte, Vue, Solid പോലുള്ള ഫ്രെയിംവർക്കുകൾക്ക് അവരുടെ കംപൈലറുകളെ ഭാഷയുടെ ഭാഗമാക്കാൻ സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ് ഉപയോഗിക്കാം. Svelte കംപോണന്റുകളെ ഒപ്റ്റിമൈസ് ചെയ്ത വാനില ജാവാസ്ക്രിപ്റ്റാക്കി മാറ്റുന്ന Svelte കംപൈലർ ഒരു മാക്രോ ആയി നടപ്പിലാക്കാൻ കഴിയും. JSX ഒരു സ്റ്റാൻഡേർഡ് മാക്രോ ആയി മാറിയേക്കാം, ഇത് ഓരോ ടൂളിനും ട്രാൻസ്ഫോമിന്റെ സ്വന്തം കസ്റ്റം ഇംപ്ലിമെന്റേഷൻ ആവശ്യമില്ലാതാക്കുന്നു.

CSS-in-JS ലൈബ്രറികൾക്ക് അവരുടെ എല്ലാ സ്റ്റൈൽ പാഴ്സിംഗും സ്റ്റാറ്റിക് റൂൾ ജനറേഷനും ബിൽഡ് സമയത്ത് ചെയ്യാൻ കഴിയും, ഇത് ഒരു മിനിമൽ റൺടൈം അല്ലെങ്കിൽ സീറോ റൺടൈം പോലും നൽകുന്നു, ഇത് കാര്യമായ പ്രകടന മെച്ചപ്പെടുത്തലുകളിലേക്ക് നയിക്കുന്നു.

ടൂളിംഗ് ഡെവലപ്പർമാർക്ക്

Vite, Webpack, esbuild തുടങ്ങിയവയുടെ സ്രഷ്‌ടാക്കൾക്ക്, ഈ നിർദ്ദേശം ശക്തവും നിലവാരമുള്ളതുമായ ഒരു എക്സ്റ്റൻഷൻ പോയിന്റ് വാഗ്ദാനം ചെയ്യുന്നു. ടൂളുകൾക്കിടയിൽ വ്യത്യാസമുള്ള ഒരു സങ്കീർണ്ണ പ്ലഗിൻ API-യെ ആശ്രയിക്കുന്നതിനുപകരം, അവർക്ക് ഭാഷയുടെ സ്വന്തം ബിൽഡ്-ടൈം ഘട്ടത്തിലേക്ക് നേരിട്ട് ഹുക്ക് ചെയ്യാൻ കഴിയും. ഇത് കൂടുതൽ ഏകീകൃതവും പരസ്പരം പ്രവർത്തിക്കാവുന്നതുമായ ഒരു ടൂളിംഗ് ഇക്കോസിസ്റ്റത്തിലേക്ക് നയിച്ചേക്കാം, അവിടെ ഒരു ടൂളിനായി എഴുതിയ ഒരു മാക്രോ മറ്റൊന്നിൽ സുഗമമായി പ്രവർത്തിക്കുന്നു.

ആപ്ലിക്കേഷൻ ഡെവലപ്പർമാർക്ക്

എല്ലാ ദിവസവും ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ എഴുതുന്ന ദശലക്ഷക്കണക്കിന് ഡെവലപ്പർമാർക്ക്, പ്രയോജനങ്ങൾ നിരവധിയാണ്:

• ലളിതമായ ബിൽഡ് കോൺഫിഗറേഷനുകൾ: TypeScript, JSX, അല്ലെങ്കിൽ കോഡ് ജനറേഷൻ പോലുള്ള സാധാരണ ജോലികൾക്കായി സങ്കീർണ്ണമായ പ്ലഗിൻ ശൃംഖലകളെ ആശ്രയിക്കുന്നത് കുറയുന്നു.
• മെച്ചപ്പെട്ട പ്രകടനം: യഥാർത്ഥ സീറോ-കോസ്റ്റ് അബ്സ്ട്രാക്ഷനുകൾ ചെറിയ ബണ്ടിൽ വലുപ്പത്തിലേക്കും വേഗതയേറിയ റൺടൈം എക്സിക്യൂഷനിലേക്കും നയിക്കും.
• മെച്ചപ്പെട്ട ഡെവലപ്പർ അനുഭവം: ഭാഷയിലേക്ക് കസ്റ്റം, ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട എക്സ്റ്റൻഷനുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവ് പ്രകടനക്ഷമതയുടെയും ബോയിലർപ്ലേറ്റ് കുറയ്ക്കുന്നതിന്റെയും പുതിയ തലങ്ങൾ തുറക്കും.

നിലവിലെ അവസ്ഥയും മുന്നോട്ടുള്ള വഴിയും

ജാവാസ്ക്രിപ്റ്റിനെ സ്റ്റാൻഡേർഡ് ചെയ്യുന്ന കമ്മറ്റിയായ TC39 വികസിപ്പിക്കുന്ന ഒരു നിർദ്ദേശമാണ് സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ്. TC39 പ്രക്രിയയ്ക്ക് നാല് പ്രധാന ഘട്ടങ്ങളുണ്ട്, സ്റ്റേജ് 1 (നിർദ്ദേശം) മുതൽ സ്റ്റേജ് 4 വരെ (പൂർത്തിയായി, ഭാഷയിൽ ഉൾപ്പെടുത്താൻ തയ്യാറാണ്).

2023 അവസാനത്തോടെ, "സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ്" നിർദ്ദേശം (അതിന്റെ സഹചാരിയായ മാക്രോകൾക്കൊപ്പം) സ്റ്റേജ് 2-ലാണ്. ഇതിനർത്ഥം കമ്മറ്റി ഡ്രാഫ്റ്റ് അംഗീകരിക്കുകയും വിശദമായ സ്പെസിഫിക്കേഷനിൽ സജീവമായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു എന്നാണ്. പ്രധാന സിന്റാക്സും സെമാന്റിക്സും വലിയ തോതിൽ തീരുമാനിക്കപ്പെട്ടു, ഈ ഘട്ടത്തിലാണ് ഫീഡ്ബാക്ക് നൽകുന്നതിനായി പ്രാഥമിക നടപ്പാക്കലുകളും പരീക്ഷണങ്ങളും പ്രോത്സാഹിപ്പിക്കുന്നത്.

ഇതിനർത്ഥം നിങ്ങൾക്ക് ഇന്ന് നിങ്ങളുടെ ബ്രൗസറിലോ Node.js പ്രോജക്റ്റിലോ import source ഉപയോഗിക്കാൻ കഴിയില്ല. എന്നിരുന്നാലും, നിർദ്ദേശം സ്റ്റേജ് 3-ലേക്ക് പക്വത പ്രാപിക്കുന്നതിനനുസരിച്ച്, അത്യാധുനിക ബിൽഡ് ടൂളുകളിലും ട്രാൻസ്പൈലറുകളിലും പരീക്ഷണാത്മക പിന്തുണ ദൃശ്യമാകുമെന്ന് നമുക്ക് പ്രതീക്ഷിക്കാം. ഏറ്റവും പുതിയ വിവരങ്ങൾ അറിയാനുള്ള ഏറ്റവും നല്ല മാർഗം GitHub-ലെ ഔദ്യോഗിക TC39 നിർദ്ദേശങ്ങൾ പിന്തുടരുക എന്നതാണ്.

ഉപസംഹാരം: ഭാവി ബിൽഡ്-ടൈമാണ്

ഇഎസ് മൊഡ്യൂളുകൾ അവതരിപ്പിച്ചതിനുശേഷമുള്ള ജാവാസ്ക്രിപ്റ്റിന്റെ ചരിത്രത്തിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ആർക്കിടെക്ചറൽ മാറ്റങ്ങളിലൊന്നാണ് സോഴ്സ് ഫേസ് ഇമ്പോർട്ട്സ്. ബിൽഡ്-ടൈമും റൺടൈമും തമ്മിൽ ഔപചാരികവും നിലവാരമുള്ളതുമായ ഒരു വേർതിരിവ് സൃഷ്ടിക്കുന്നതിലൂടെ, ഈ നിർദ്ദേശം ഭാഷയിലെ ഒരു അടിസ്ഥാനപരമായ വിടവ് നികത്തുന്നു. ഇത് ഡെവലപ്പർമാർ ദീർഘകാലമായി ആഗ്രഹിച്ചിരുന്ന കഴിവുകൾ—മാക്രോകൾ, കംപൈൽ-ടൈം മെറ്റാപ്രോഗ്രാമിംഗ്, യഥാർത്ഥ സീറോ-കോസ്റ്റ് അബ്സ്ട്രാക്ഷനുകൾ—കസ്റ്റം, വിഘടിച്ച ടൂളിംഗിന്റെ മണ്ഡലത്തിൽ നിന്ന് ജാവാസ്ക്രിപ്റ്റിന്റെ കാതലിലേക്ക് കൊണ്ടുവരുന്നു.

ഇതൊരു പുതിയ സിന്റാക്സ് മാത്രമല്ല; ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് നമ്മൾ എങ്ങനെ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഒരു പുതിയ ചിന്താരീതിയാണിത്. ഇത് കൂടുതൽ ലോജിക് ഉപയോക്താവിന്റെ ഉപകരണത്തിൽ നിന്ന് ഡെവലപ്പറുടെ മെഷീനിലേക്ക് മാറ്റാൻ ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു, അതിന്റെ ഫലമായി കൂടുതൽ ശക്തവും പ്രകടനാത്മകവുമായ ആപ്ലിക്കേഷനുകൾ മാത്രമല്ല, വേഗതയേറിയതും കൂടുതൽ കാര്യക്ഷമവുമായവയും ലഭിക്കുന്നു. നിർദ്ദേശം സ്റ്റാൻഡേർഡൈസേഷനിലേക്കുള്ള അതിന്റെ യാത്ര തുടരുമ്പോൾ, ആഗോള ജാവാസ്ക്രിപ്റ്റ് സമൂഹം മുഴുവൻ ആകാംക്ഷയോടെ കാത്തിരിക്കണം. ബിൽഡ്-ടൈം നവീകരണത്തിന്റെ ഒരു പുതിയ യുഗം തൊട്ടടുത്തുണ്ട്.